home *** CD-ROM | disk | FTP | other *** search
/ Aminet 51 / Aminet 51 (2002)(GTI - Schatztruhe)[!][Oct 2002].iso / Aminet / dev / c / TinyGL.lha / tinygl / src / api.c next >
Encoding:
C/C++ Source or Header  |  2002-08-25  |  8.9 KB  |  667 lines

  1. #include "zgl.h"
  2. #include <stdio.h>
  3. /* glVertex */
  4.  
  5. void glVertex4f(float x,float y,float z,float w)
  6. {
  7.   GLParam p[5];
  8.  
  9.   p[0].op=OP_Vertex;
  10.   p[1].f=x;
  11.   p[2].f=y;
  12.   p[3].f=z;
  13.   p[4].f=w;
  14.  
  15.   gl_add_op(p);
  16. }
  17.  
  18. void glVertex2f(float x,float y) 
  19. {
  20.   glVertex4f(x,y,0,1);
  21. }
  22.  
  23. void glVertex3f(float x,float y,float z) 
  24. {
  25.   glVertex4f(x,y,z,1);
  26. }
  27.  
  28. void glVertex3fv(float *v) 
  29. {
  30.   glVertex4f(v[0],v[1],v[2],1);
  31. }
  32.  
  33. /* glNormal */
  34.  
  35. void glNormal3f(float x,float y,float z)
  36. {
  37.   GLParam p[4];
  38.  
  39.   p[0].op=OP_Normal;
  40.   p[1].f=x;
  41.   p[2].f=y;
  42.   p[3].f=z;
  43.  
  44.   gl_add_op(p);
  45. }
  46.  
  47. void glNormal3fv(float *v) 
  48. {
  49.   glNormal3f(v[0],v[1],v[2]);
  50. }
  51.  
  52. /* glColor */
  53.  
  54. void glColor4f(float r,float g,float b,float a)
  55. {
  56.   GLParam p[8];
  57.  
  58.   p[0].op=OP_Color;
  59.   p[1].f=r;
  60.   p[2].f=g;
  61.   p[3].f=b;
  62.   p[4].f=a;
  63.   /* direct convertion to integer to go faster if no shading */
  64.   p[5].ui = (unsigned int) (r * (ZB_POINT_RED_MAX - ZB_POINT_RED_MIN) + 
  65.                             ZB_POINT_RED_MIN);
  66.   p[6].ui = (unsigned int) (g * (ZB_POINT_GREEN_MAX - ZB_POINT_GREEN_MIN) + 
  67.                             ZB_POINT_GREEN_MIN);
  68.   p[7].ui = (unsigned int) (b * (ZB_POINT_BLUE_MAX - ZB_POINT_BLUE_MIN) + 
  69.                             ZB_POINT_BLUE_MIN);
  70.   gl_add_op(p);
  71. }
  72.  
  73. void glColor4fv(float *v)
  74. {
  75.   GLParam p[8];
  76.  
  77.   p[0].op=OP_Color;
  78.   p[1].f=v[0];
  79.   p[2].f=v[1];
  80.   p[3].f=v[2];
  81.   p[4].f=v[3];
  82.   /* direct convertion to integer to go faster if no shading */
  83.   p[5].ui = (unsigned int) (v[0] * (ZB_POINT_RED_MAX - ZB_POINT_RED_MIN) + 
  84.                             ZB_POINT_RED_MIN);
  85.   p[6].ui = (unsigned int) (v[1] * (ZB_POINT_GREEN_MAX - ZB_POINT_GREEN_MIN) + 
  86.                             ZB_POINT_GREEN_MIN);
  87.   p[7].ui = (unsigned int) (v[2] * (ZB_POINT_BLUE_MAX - ZB_POINT_BLUE_MIN) + 
  88.                             ZB_POINT_BLUE_MIN);
  89.   gl_add_op(p);
  90. }
  91.  
  92. void glColor3f(float x,float y,float z) 
  93. {
  94.   glColor4f(x,y,z,1);
  95. }
  96.  
  97. void glColor3fv(float *v) 
  98. {
  99.   glColor4f(v[0],v[1],v[2],1);
  100. }
  101.  
  102.  
  103. /* TexCoord */
  104.  
  105. void glTexCoord4f(float s,float t,float r,float q)
  106. {
  107.   GLParam p[5];
  108.  
  109.   p[0].op=OP_TexCoord;
  110.   p[1].f=s;
  111.   p[2].f=t;
  112.   p[3].f=r;
  113.   p[4].f=q;
  114.  
  115.   gl_add_op(p);
  116. }
  117.  
  118. void glTexCoord2f(float s,float t)
  119. {
  120.   glTexCoord4f(s,t,0,1);
  121. }
  122.  
  123. void glTexCoord2fv(float *v)
  124. {
  125.   glTexCoord4f(v[0],v[1],0,1);
  126. }
  127.  
  128. void glEdgeFlag(int flag)
  129. {
  130.   GLParam p[2];
  131.  
  132.   p[0].op=OP_EdgeFlag;
  133.   p[1].i=flag;
  134.  
  135.   gl_add_op(p);
  136. }
  137.  
  138. /* misc */
  139.  
  140. void glShadeModel(int mode)
  141. {
  142.   GLParam p[2];
  143.  
  144.   assert(mode == GL_FLAT || mode == GL_SMOOTH);
  145.  
  146.   p[0].op=OP_ShadeModel;
  147.   p[1].i=mode;
  148.  
  149.   gl_add_op(p);
  150. }
  151.  
  152. void glCullFace(int mode)
  153. {
  154.   GLParam p[2];
  155.  
  156.   assert(mode == GL_BACK || 
  157.          mode == GL_FRONT || 
  158.          mode == GL_FRONT_AND_BACK);
  159.  
  160.   p[0].op=OP_CullFace;
  161.   p[1].i=mode;
  162.  
  163.   gl_add_op(p);
  164. }
  165.  
  166. void glFrontFace(int mode)
  167. {
  168.   GLParam p[2];
  169.  
  170.   assert(mode == GL_CCW || mode == GL_CW);
  171.  
  172.   mode = (mode != GL_CCW);
  173.  
  174.   p[0].op=OP_FrontFace;
  175.   p[1].i=mode;
  176.  
  177.   gl_add_op(p);
  178. }
  179.  
  180. void glPolygonMode(int face,int mode)
  181. {
  182.   GLParam p[3];
  183.  
  184.   assert(face == GL_BACK || 
  185.          face == GL_FRONT || 
  186.          face == GL_FRONT_AND_BACK);
  187.   assert(mode == GL_POINT || mode == GL_LINE || mode==GL_FILL);
  188.  
  189.   p[0].op=OP_PolygonMode;
  190.   p[1].i=face;
  191.   p[2].i=mode;
  192.  
  193.   gl_add_op(p);
  194. }
  195.  
  196.  
  197. /* glEnable / glDisable */
  198.  
  199. void glEnable(int cap)
  200. {
  201.   GLParam p[3];
  202.  
  203.   p[0].op=OP_EnableDisable;
  204.   p[1].i=cap;
  205.   p[2].i=1;
  206.  
  207.   gl_add_op(p);
  208. }
  209.  
  210. void glDisable(int cap)
  211. {
  212.   GLParam p[3];
  213.  
  214.   p[0].op=OP_EnableDisable;
  215.   p[1].i=cap;
  216.   p[2].i=0;
  217.  
  218.   gl_add_op(p);
  219. }
  220.  
  221. /* glBegin / glEnd */
  222.  
  223. void glBegin(int mode)
  224. {
  225.   GLParam p[2];
  226.  
  227.   p[0].op=OP_Begin;
  228.   p[1].i=mode;
  229.  
  230.   gl_add_op(p);
  231. }
  232.  
  233. void glEnd(void)
  234. {
  235.   GLParam p[1];
  236.  
  237.   p[0].op=OP_End;
  238.  
  239.   gl_add_op(p);
  240. }
  241.  
  242. /* matrix */
  243.  
  244. void glMatrixMode(int mode)
  245. {
  246.   GLParam p[2];
  247.  
  248.   p[0].op=OP_MatrixMode;
  249.   p[1].i=mode;
  250.  
  251.   gl_add_op(p);
  252. }
  253.  
  254. void glLoadMatrixf(const float *m)
  255. {
  256.   GLParam p[17];
  257.   int i;
  258.  
  259.   p[0].op=OP_LoadMatrix;
  260.   for(i=0;i<16;i++) p[i+1].f=m[i];
  261.  
  262.   gl_add_op(p);
  263. }
  264.  
  265. void glLoadIdentity(void)
  266. {
  267.   GLParam p[1];
  268.  
  269.   p[0].op=OP_LoadIdentity;
  270.  
  271.   gl_add_op(p);
  272. }
  273.  
  274. void glMultMatrixf(const float *m)
  275. {
  276.   GLParam p[17];
  277.   int i;
  278.  
  279.   p[0].op=OP_MultMatrix;
  280.   for(i=0;i<16;i++) p[i+1].f=m[i];
  281.  
  282.   gl_add_op(p);
  283. }
  284.  
  285. void glPushMatrix(void)
  286. {
  287.   GLParam p[1];
  288.  
  289.   p[0].op=OP_PushMatrix;
  290.  
  291.   gl_add_op(p);
  292. }
  293.  
  294. void glPopMatrix(void)
  295. {
  296.   GLParam p[1];
  297.  
  298.   p[0].op=OP_PopMatrix;
  299.  
  300.   gl_add_op(p);
  301. }
  302.  
  303. void glRotatef(float angle,float x,float y,float z)
  304. {
  305.   GLParam p[5];
  306.  
  307.   p[0].op=OP_Rotate;
  308.   p[1].f=angle;
  309.   p[2].f=x;
  310.   p[3].f=y;
  311.   p[4].f=z;
  312.  
  313.   gl_add_op(p);
  314. }
  315.  
  316. void glTranslatef(float x,float y,float z)
  317. {
  318.   GLParam p[4];
  319.  
  320.   p[0].op=OP_Translate;
  321.   p[1].f=x;
  322.   p[2].f=y;
  323.   p[3].f=z;
  324.  
  325.   gl_add_op(p);
  326. }
  327.  
  328. void glScalef(float x,float y,float z)
  329. {
  330.   GLParam p[4];
  331.  
  332.   p[0].op=OP_Scale;
  333.   p[1].f=x;
  334.   p[2].f=y;
  335.   p[3].f=z;
  336.  
  337.   gl_add_op(p);
  338. }
  339.  
  340.  
  341. void glViewport(int x,int y,int width,int height)
  342. {
  343.   GLParam p[5];
  344.  
  345.   p[0].op=OP_Viewport;
  346.   p[1].i=x;
  347.   p[2].i=y;
  348.   p[3].i=width;
  349.   p[4].i=height;
  350.  
  351.   gl_add_op(p);
  352. }
  353.  
  354. void glFrustum(double left,double right,double bottom,double top,
  355.                              double nearv,double farv)
  356. {
  357.   GLParam p[7];
  358.  
  359.   p[0].op=OP_Frustum;
  360.   p[1].f=left;
  361.   p[2].f=right;
  362.   p[3].f=bottom;
  363.   p[4].f=top;
  364.     p[5].f=nearv;
  365.   p[6].f=farv;
  366.  
  367.   gl_add_op(p);
  368. }
  369.  
  370. /* lightening */
  371.  
  372. void glMaterialfv(int mode,int type,float *v)
  373. {
  374.   GLParam p[7];
  375.   int i,n;
  376.  
  377.   assert(mode == GL_FRONT  || mode == GL_BACK || mode==GL_FRONT_AND_BACK);
  378.  
  379.   p[0].op=OP_Material;
  380.   p[1].i=mode;
  381.   p[2].i=type;
  382.   n=4;
  383.   if (type == GL_SHININESS) n=1;
  384.   for(i=0;i<4;i++) p[3+i].f=v[i];
  385.   for(i=n;i<4;i++) p[3+i].f=0;
  386.  
  387.   gl_add_op(p);
  388. }
  389.  
  390. void glMaterialf(int mode,int type,float v)
  391. {
  392.   GLParam p[7];
  393.   int i;
  394.  
  395.   p[0].op=OP_Material;
  396.   p[1].i=mode;
  397.   p[2].i=type;
  398.   p[3].f=v;
  399.   for(i=0;i<3;i++) p[4+i].f=0;
  400.  
  401.   gl_add_op(p);
  402. }
  403.  
  404. void glColorMaterial(int mode,int type)
  405. {
  406.   GLParam p[3];
  407.  
  408.   p[0].op=OP_ColorMaterial;
  409.   p[1].i=mode;
  410.   p[2].i=type;
  411.  
  412.   gl_add_op(p);
  413. }
  414.  
  415. void glLightfv(int light,int type,float *v)
  416. {
  417.   GLParam p[7];
  418.   int i;
  419.  
  420.   p[0].op=OP_Light;
  421.   p[1].i=light;
  422.   p[2].i=type;
  423.   /* TODO: 3 composants ? */
  424.   for(i=0;i<4;i++) p[3+i].f=v[i];
  425.  
  426.   gl_add_op(p);
  427. }
  428.  
  429.  
  430. void glLightf(int light,int type,float v)
  431. {
  432.   GLParam p[7];
  433.   int i;
  434.  
  435.   p[0].op=OP_Light;
  436.   p[1].i=light;
  437.   p[2].i=type;
  438.   p[3].f=v;
  439.   for(i=0;i<3;i++) p[4+i].f=0;
  440.  
  441.   gl_add_op(p);
  442. }
  443.  
  444. void glLightModeli(int pname,int param)
  445. {
  446.   GLParam p[6];
  447.   int i;
  448.  
  449.   p[0].op=OP_LightModel;
  450.   p[1].i=pname;
  451.   p[2].f=(float)param;
  452.   for(i=0;i<4;i++) p[3+i].f=0;
  453.  
  454.   gl_add_op(p);
  455. }
  456.  
  457. void glLightModelfv(int pname,float *param)
  458. {
  459.   GLParam p[6];
  460.   int i;
  461.  
  462.   p[0].op=OP_LightModel;
  463.   p[1].i=pname;
  464.   for(i=0;i<4;i++) p[2+i].f=param[i];
  465.  
  466.   gl_add_op(p);
  467. }
  468.  
  469. /* clear */
  470.  
  471. void glClear(int mask)
  472. {
  473.   GLParam p[2];
  474.  
  475.   p[0].op=OP_Clear;
  476.   p[1].i=mask;
  477.  
  478.   gl_add_op(p);
  479. }
  480.  
  481. void glClearColor(float r,float g,float b,float a)
  482. {
  483.   GLParam p[5];
  484.  
  485.   p[0].op=OP_ClearColor;
  486.   p[1].f=r;
  487.   p[2].f=g;
  488.   p[3].f=b;
  489.   p[4].f=a;
  490.  
  491.   gl_add_op(p);
  492. }
  493.  
  494. void glClearDepth(double depth)
  495. {
  496.   GLParam p[2];
  497.  
  498.   p[0].op=OP_ClearDepth;
  499.   p[1].f=depth;
  500.  
  501.   gl_add_op(p);
  502. }
  503.  
  504.  
  505. /* textures */
  506.  
  507. void glTexImage2D( int target, int level, int components,
  508.                    int width, int height, int border,
  509.                    int format, int type, void *pixels)
  510. {
  511.   GLParam p[10];
  512.  
  513.   p[0].op=OP_TexImage2D;
  514.   p[1].i=target;
  515.   p[2].i=level;
  516.   p[3].i=components;
  517.   p[4].i=width;
  518.   p[5].i=height;
  519.   p[6].i=border;
  520.   p[7].i=format;
  521.   p[8].i=type;
  522.   p[9].p=pixels;
  523.  
  524.   gl_add_op(p);
  525. }
  526.  
  527.  
  528. void glBindTexture(int target,int texture)
  529. {
  530.   GLParam p[3];
  531.  
  532.   p[0].op=OP_BindTexture;
  533.   p[1].i=target;
  534.   p[2].i=texture;
  535.  
  536.   gl_add_op(p);
  537. }
  538.  
  539. void glTexEnvi(int target,int pname,int param)
  540. {
  541.   GLParam p[8];
  542.   
  543.   p[0].op=OP_TexEnv;
  544.   p[1].i=target;
  545.   p[2].i=pname;
  546.   p[3].i=param;
  547.   p[4].f=0;
  548.   p[5].f=0;
  549.   p[6].f=0;
  550.   p[7].f=0;
  551.  
  552.   gl_add_op(p);
  553. }
  554.  
  555. void glTexParameteri(int target,int pname,int param)
  556. {
  557.   GLParam p[8];
  558.   
  559.   p[0].op=OP_TexParameter;
  560.   p[1].i=target;
  561.   p[2].i=pname;
  562.   p[3].i=param;
  563.   p[4].f=0;
  564.   p[5].f=0;
  565.   p[6].f=0;
  566.   p[7].f=0;
  567.  
  568.   gl_add_op(p);
  569. }
  570.  
  571. void glPixelStorei(int pname,int param)
  572. {
  573.   GLParam p[3];
  574.  
  575.   p[0].op=OP_PixelStore;
  576.   p[1].i=pname;
  577.   p[2].i=param;
  578.  
  579.   gl_add_op(p);
  580. }
  581.  
  582. /* selection */
  583.  
  584. void glInitNames(void)
  585. {
  586.   GLParam p[1];
  587.  
  588.   p[0].op=OP_InitNames;
  589.  
  590.   gl_add_op(p);
  591. }
  592.  
  593. void glPushName(unsigned int name)
  594. {
  595.   GLParam p[2];
  596.  
  597.   p[0].op=OP_PushName;
  598.   p[1].i=name;
  599.  
  600.   gl_add_op(p);
  601. }
  602.  
  603. void glPopName(void)
  604. {
  605.   GLParam p[1];
  606.  
  607.   p[0].op=OP_PopName;
  608.  
  609.   gl_add_op(p);
  610. }
  611.  
  612. void glLoadName(unsigned int name)
  613. {
  614.   GLParam p[2];
  615.  
  616.   p[0].op=OP_LoadName;
  617.   p[1].i=name;
  618.  
  619.   gl_add_op(p);
  620. }
  621.  
  622. void 
  623. glPolygonOffset(GLfloat factor, GLfloat units)
  624. {
  625.   GLParam p[3];
  626.   p[0].op = OP_PolygonOffset;
  627.   p[1].f = factor;
  628.   p[2].f = units;
  629. }
  630.  
  631. /* Special Functions */
  632.  
  633. void glCallList(unsigned int list)
  634. {
  635.   GLParam p[2];
  636.  
  637.   p[0].op=OP_CallList;
  638.   p[1].i=list;
  639.  
  640.   gl_add_op(p);
  641. }
  642.  
  643. void glFlush(void)
  644. {
  645.   /* nothing to do */
  646. }
  647.  
  648. void glHint(int target,int mode)
  649. {
  650.   GLParam p[3];
  651.  
  652.   p[0].op=OP_Hint;
  653.   p[1].i=target;
  654.   p[2].i=mode;
  655.  
  656.   gl_add_op(p);
  657. }
  658.  
  659. /* Non standard functions */
  660.  
  661. void glDebug(int mode)
  662. {
  663.   GLContext *c=gl_get_context();
  664.   c->print_flag=mode;
  665. }
  666.  
  667.